Symbol's function definition is void: clojure-project-dir

#+BEGIN_SRC clojure
    (defn foo [x] (inc x))
    (foo 2)
    #+END_SRC

    #+RESULTS:
    : #'user/foo3

#+BEGIN_SRC emacs-lisp
    (+ 1 1)
    (+ 3 4)
    #+END_SRC

    #+RESULTS:
    : 7

defproject my-project "0.0.1-SNAPSHOT"
  [...]
  :java-source-paths ["src/java" "test/java”])

For projects that include some Java code, you can set the :java-source-path key in project.clj to a directory containing Java files. Then the javac compiler will run before your Clojure code is AOT-compiled, or you can run it manually with the javac task.

(("gnu" . "")
 ("melpa" . "")
 ("marmalade" . ""))

(with-current-buffer (url-retrieve-synchronously "") (buffer-string))

(with-current-buffer (url-retrieve-synchronously "") (buffer-string))

;; Define package repositories
(require 'package)
(require 'erc)

(add-to-list 'package-archives
             '("marmalade" . "") t)
(add-to-list 'package-archives
             '("tromey" . "") t)
(add-to-list 'package-archives
             '("melpa" . "") t)
(add-to-list 'package-archives
              '("org" . "") t)

C-h b

Major Mode Bindings:
key             binding
---             -------

C-c		Prefix Command
C-j		cider-repl-newline-and-indent
RET		cider-repl-return
C-x		Prefix Command
ESC		Prefix Command
,		cider-repl-handle-shortcut
<C-down>	cider-repl-forward-input
<C-return>	cider-repl-closing-return
<C-up>		cider-repl-backward-input
<S-home>	cider-repl-bol-mark

C-x C-e		cider-eval-last-sexp

M-,		cider-pop-back
M-.		cider-find-var
M-n		cider-repl-next-input
M-p		cider-repl-previous-input
M-r		cider-repl-previous-matching-input
M-s		cider-repl-next-matching-input

C-c C-b .. C-c C-c		cider-interrupt
C-c C-d		cider-doc-map
C-c RET		cider-macroexpand-1
C-c C-n		cider-repl-next-prompt
C-c C-o		cider-repl-clear-output
C-c C-p		cider-repl-previous-prompt
C-c C-q		cider-quit
C-c C-r		cider-eval-region
C-c C-u		cider-repl-kill-input
C-c C-x		cider-refresh
C-c C-z		cider-switch-to-last-clojure-buffer
C-c ESC		Prefix Command
C-c C-.		cider-find-ns

C-c M-.		cider-find-resource
C-c M-i		cider-inspect
C-c M-m		cider-macroexpand-all
C-c M-n		cider-repl-set-ns
C-c M-o		cider-repl-switch-to-other
C-c M-s		cider-selector
C-c M-t		Prefix Command

C-c M-t n	cider-toggle-trace-ns
C-c M-t v	cider-toggle-trace-var

C-c C-d C-a	cider-apropos
C-c C-d C-d	cider-doc
C-c C-d C-j	cider-javadoc
C-c C-d C-r	cider-grimoire
C-c C-d A	cider-apropos-documentation
C-c C-d a	cider-apropos
C-c C-d d	cider-doc
C-c C-d h	cider-grimoire-web
C-c C-d j	cider-javadoc
C-c C-d r	cider-grimoire

C-h f cider-macroexpand-1

cider-macroexpand-1 is an interactive autoloaded Lisp function in
`cider-macroexpansion.el'.

It is bound to C-c RET, <menu-bar> <REPL> <Macroexpand>
<Macroexpand-1>.

(cider-macroexpand-1 &optional PREFIX)

Invoke 'macroexpand-1' on the expression preceding point.
If invoked with a PREFIX argument, use 'macroexpand' instead of
'macroexpand-1'.

[back]

~/Code/tob/src/tob $ inf-clojure-completions foo
End of file during parsing

boot.user=> (complete.core/completions "hi")
("hiccup.compiler" "hiccup.core" "hiccup.def" "hiccup.page" "hiccup.util")

(deftask exp []
  (comp
     (watch)
     (expectations)))

(define-clojure-indent
  (for-all 1)
  (quick-check 1))

(define-clojure-indent
  (GET* 1)
  (POST* 1))

(GET* :foo
  :bar)

(POST* :foo
  :bar)

(GET* "/hello" []
  :query-params [name :- String]
  (ok {:message (str "Hello, " name)}))

(eval-after-load 'paredit
  #'(define-key paredit-mode-map [remap newline-and-indent] 'paredit-newline))

(use-package markdown-mode
  :mode ("\\.md\\'" . markdown-mode)
  :init (progn
          (add-hook 'markdown-mode-hook
                    (lambda () (setq truncate-lines nil)))))

If you're using the latest railwaycat Mac port of Emacs, you can instead use:

(mac-auto-operator-composition-mode)

(defconst js-indent-level 2)

(let ((json-reformat:indent-width js-indent-level))

(let (( js-indent-level json-reformat:indent-width))

json-reformat:indent-width (integer)

    Change indentation level (default 4)

(defcustom json-reformat:indent-width 2
  "How much indentation `json-reformat-region' should do at each level."
  :type 'integer
  :safe #'integerp
  :group 'json-reformat)

;;;###autoload
(setq js-indent-level 2)
(defun json-mode-beautify ()
  "Beautify / pretty-print the active region (or the entire buffer if no active region)."
  (interactive)
  (let ((json-reformat:indent-width js-indent-level ))
    (if (use-region-p)
        (json-reformat-region (region-beginning) (region-end))
      (json-reformat-region (buffer-end -1) (buffer-end 1)))))

(define-key json-mode-map (kbd "C-c C-f") 'json-mode-beautify)

(defun service-application-query ()
  (let ((url-request-method "GET"))
    (url-retrieve service-application-manager-url
                  (lambda (status)
                    (re-search-forward "\r?\n\r?\n")
                    (json->table-entries (buffer-string))))))

(when (eq system-type 'darwin)
  (setq mac-right-option-modifier 'none))

(defun paredit-kill-parent-sexp (&optional arg)
  (interactive)
  (paredit-backward-up)
  (kill-sexp (or arg 1)))

;; 
(org-babel-do-load-languages
    'org-babel-load-languages '((js . t) (python . t) (R . t)))
(require 'cider)
(require 'ob-clojure)
(setq org-babel-clojure-backend 'cider)

(defun clojure-expected-ns-from-classpath ()
  (let* ((file-path (buffer-file-name))
         (relpath (reduce (lambda (r p)
                            (let ((relpath (when (string/starts-with file-path p)
                                             (substring file-path (length p)))))
                              (cond ((not relpath) r)
                                    ((not r) relpath)
                                    ((< (length relpath) (length r)) relpath)
                                    (t r))))
                          (cider-sync-request:classpath)
                          :initial-value nil)))
    (when relpath
      (let* ((sans-type (substring
                         relpath 0 (- (length (file-name-extension relpath
                                                                        t)))))
             (ns (mapconcat 'identity (cdr (split-string sans-type "/")) "."))
             (ns (replace-regexp-in-string "_" "-" ns)))
        ns))))

(ns lambdaisland.scratch)

(require 'cemerick.friend.credentials)

(bcrypt-credential-fn)

java.lang.RuntimeException: Unable to resolve symbol: bcrypt-credential-fn in this context, compiling:(/home/arne/LambdaIsland/app/src/lambdaisland/scratch.clj:5:1)

C-( runs the command sp-rewrap-sexp, which is an interactive compiled
Lisp function in `smartparens.el'.

It is bound to C-(.

(sp-rewrap-sexp PAIR &optional KEEP-OLD)

;; change surround
(define-key sp-keymap (kbd "C-(") 'sp-rewrap-sexp)

#+BEGIN_SRC clojure
(+ 1 1)
#+END_SRC

#+RESULTS:
: 2